package com.cmdb.system.service.impl;

import com.cmdb.common.utils.DateUtils;
import com.cmdb.common.utils.DictUtils;
import com.cmdb.common.utils.SecurityUtils;
import com.cmdb.common.utils.StringUtils;
import com.cmdb.common.exception.ServiceException;
import com.cmdb.system.domain.SysAssetGx;
import com.cmdb.system.domain.SysAssetInfo;
import com.cmdb.system.domain.vo.AssetStatisticsVO;
import com.cmdb.system.mapper.SysAssetGxMapper;
import com.cmdb.system.mapper.SysAssetInfoMapper;
import com.cmdb.system.service.ISysAssetInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 资产信息Service业务层处理
 * 
 * @author 陈玉强
 * @date 2025-06-01
 */
@Service
public class SysAssetInfoServiceImpl implements ISysAssetInfoService 
{
    @Resource
    private SysAssetInfoMapper sysAssetInfoMapper;
    @Autowired
    private SysAssetGxMapper sysAssetGxMapper;
    /**
     * 查询资产信息
     * 
     * @param assetId 资产信息主键
     * @return 资产信息
     */
    @Override
    public SysAssetInfo selectSysAssetInfoByAssetId(Long assetId)
    {
        SysAssetInfo sysAssetInfo = sysAssetInfoMapper.selectSysAssetInfoByAssetId(assetId);
        SysAssetGx sysAssetGx = new SysAssetGx();
        sysAssetGx.setAssetId(sysAssetInfo.getAssetId());
        List<SysAssetGx> sysAssetGxes = sysAssetGxMapper.selectSysAssetGxList(sysAssetGx);
        sysAssetInfo.setSysAssetGx(sysAssetGxes);
        return sysAssetInfo;
    }

    /**
     * 查询资产信息列表
     * 
     * @param sysAssetInfo 资产信息
     * @return 资产信息
     */
    @Override
    public List<SysAssetInfo> selectSysAssetInfoList(SysAssetInfo sysAssetInfo) {

        List<SysAssetInfo> sysAssetInfos = sysAssetInfoMapper.selectSysAssetInfoList(sysAssetInfo);
        //增加sysAssetInfo 转义
        for (SysAssetInfo info : sysAssetInfos) {

            //身份信息 sys_info_type
            info.setInfoTypeName(DictUtils.getDictLabel("sys_info_type", info.getInfoType()));
            //组织架构名称

            info.setOrgIdName(DictUtils.getDictName("dept"+info.getOrgId()));
            //单位类型
            info.setOrgTypeName(DictUtils.getDictLabel("dept_type", info.getOrgType()));
            //系统类型 sys_type
            info.setSystemTypeName(DictUtils.getDictLabel("sys_type", info.getSystemType()));
            //是否定级 sys_is_dj
            info.setIsClassifiedName(DictUtils.getDictLabel("sys_is_dj", info.getIsClassified()));
            //系统级别 sys_level
            info.setSystemLevelName(DictUtils.getDictLabel("sys_level", info.getSystemLevel()));
            //业务安全等级 sys_sc_level
            info.setBusinessSecurityLevelName(DictUtils.getDictLabel("sys_sc_level", info.getBusinessSecurityLevel()));

            //系统服务安全等级 sys_fw_level
            info.setServiceSecurityLevelName(DictUtils.getDictLabel("sys_fw_level", info.getServiceSecurityLevel()));

            //是否备案  sys_is_ba
            info.setIsFiledName(DictUtils.getDictLabel("sys_is_ba", info.getIsFiled()));

            //是否评测  sys_is_pc
            info.setIsEvaluatedName(DictUtils.getDictLabel("sys_is_pc", info.getIsEvaluated()));


            //操作系统
            //sys_xt
            info.setOsTypeName(DictUtils.getDictLabel("sys_xt", info.getOsType()));

            //中间件
            //sys_zjj
            info.setMiddlewareTypeName(DictUtils.getDictLabel("sys_zjj", info.getMiddlewareType()));

            //数据库
            //sys_db
            info.setDatabaseTypeName(DictUtils.getDictLabel("sys_db", info.getDatabaseType()));

            //应用软件产品
            //sys_app
            info.setAppProductName(DictUtils.getDictLabel("sys_app", info.getAppProduct()));

            //商用密码                    sys_is_pwd
            info.setIsSecurityEvaluatedName(DictUtils.getDictLabel("sys_is_pwd", info.getIsSecurityEvaluated()));

            //云计算服务
            //sys_is_yun
            info.setIsCloudEvaluatedName(DictUtils.getDictLabel("sys_is_yun", info.getIsCloudEvaluated()));

            //云计算服务
            //sys_status
            info.setStatusName(DictUtils.getDictLabel("sys_status", info.getStatus()));
    }
        return sysAssetInfos;
    }

    /**
     * 新增资产信息
     * 
     * @param sysAssetInfo 资产信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSysAssetInfo(SysAssetInfo sysAssetInfo)
    {

//        String orgIdName = sysAssetInfo.getOrgIdName();
//        if(null!=orgIdName){
//            sysAssetInfo.setOrgId(DictUtils.getDictName());
//        }
        if(!StringUtils.isNotEmpty(sysAssetInfo.getCreateBy())){
            sysAssetInfo.setCreateBy(SecurityUtils.getDeptId()+"");
        }

        sysAssetInfo.setCreateTime(new Date());
        int i = sysAssetInfoMapper.insertSysAssetInfo(sysAssetInfo);
        sysAssetInfo.setCreateTime(DateUtils.getNowDate());
        List<SysAssetGx> sysAssetGx = sysAssetInfo.getSysAssetGx();
        if(null!=sysAssetGx&& StringUtils.isNotEmpty(sysAssetGx.get(0).getAccessDomain())){
            for (SysAssetGx gx : sysAssetGx) {
                gx.setAssetId(sysAssetInfo.getAssetId());
                sysAssetGxMapper.insertSysAssetGx(gx);
            }
        }


        return i;
    }

    /**
     * 修改资产信息
     * 
     * @param sysAssetInfo 资产信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysAssetInfo(SysAssetInfo sysAssetInfo)
    {
        sysAssetInfo.setUpdateTime(DateUtils.getNowDate());
        int i1 = sysAssetGxMapper.deleteSysAssetGxByGxId(Long.parseLong(sysAssetInfo.getAssetId()));
        List<SysAssetGx> sysAssetGx = sysAssetInfo.getSysAssetGx();
        if(null!=sysAssetGx&& StringUtils.isNotEmpty(sysAssetGx.get(0).getAccessDomain())){
            for (SysAssetGx gx : sysAssetGx) {
                gx.setAssetId(sysAssetInfo.getAssetId());
                sysAssetGxMapper.insertSysAssetGx(gx);
            }
        }
        return sysAssetInfoMapper.updateSysAssetInfo(sysAssetInfo);
    }

    /**
     * 批量删除资产信息
     * 
     * @param assetIds 需要删除的资产信息主键
     * @return 结果
     */
    @Override
    public int deleteSysAssetInfoByAssetIds(Long[] assetIds)
    {
        return sysAssetInfoMapper.deleteSysAssetInfoByAssetIds(assetIds);
    }

    /**
     * 删除资产信息信息
     * 
     * @param assetId 资产信息主键
     * @return 结果
     */
    @Override
    public int deleteSysAssetInfoByAssetId(Long assetId)
    {
        return sysAssetInfoMapper.deleteSysAssetInfoByAssetId(assetId);
    }

    /**
     * 获取资产统计数据
     * 
     * @return 资产统计数据
     */
    @Override
    public AssetStatisticsVO getAssetStatistics()
    {
        AssetStatisticsVO statistics = new AssetStatisticsVO();
        
        // 系统类型统计（使用字典转换的SQL查询）
        statistics.setSystemTypeStats(convertToStatItems(sysAssetInfoMapper.selectSystemTypeStats()));
        
        // 操作系统统计（使用字典转换的SQL查询）
        statistics.setOsTypeStats(convertToStatItems(sysAssetInfoMapper.selectOsTypeStats()));
        
        // 中间件统计（使用字典转换的SQL查询）
        statistics.setMiddlewareStats(convertToStatItems(sysAssetInfoMapper.selectMiddlewareStats()));
        
        // 系统级别统计（使用字典转换的SQL查询）
        statistics.setSystemLevelStats(convertToStatItems(sysAssetInfoMapper.selectSystemLevelStats()));
        
        // 数据库统计（使用字典转换的SQL查询）
        statistics.setDatabaseStats(convertToStatItems(sysAssetInfoMapper.selectDatabaseStats()));
        
        // 应用软件产品统计（使用字典转换的SQL查询）
        statistics.setAppProductStats(convertToStatItems(sysAssetInfoMapper.selectAppProductStats()));
        
        return statistics;
    }

    @Override
    public AssetStatisticsVO getAssetStatistics(SysAssetInfo sysAssetInfo) {
        AssetStatisticsVO statistics = new AssetStatisticsVO();
        // 系统类型统计
        statistics.setSystemTypeStats(convertToStatItems(sysAssetInfoMapper.selectSystemTypeStatsWithFilter(sysAssetInfo)));
        // 操作系统统计
        statistics.setOsTypeStats(convertToStatItems(sysAssetInfoMapper.selectOsTypeStatsWithFilter(sysAssetInfo)));
        // 中间件统计
        statistics.setMiddlewareStats(convertToStatItems(sysAssetInfoMapper.selectMiddlewareStatsWithFilter(sysAssetInfo)));
        // 系统级别统计
        statistics.setSystemLevelStats(convertToStatItems(sysAssetInfoMapper.selectSystemLevelStatsWithFilter(sysAssetInfo)));
        // 数据库统计
        statistics.setDatabaseStats(convertToStatItems(sysAssetInfoMapper.selectDatabaseStatsWithFilter(sysAssetInfo)));
        // 应用软件产品统计
        statistics.setAppProductStats(convertToStatItems(sysAssetInfoMapper.selectAppProductStatsWithFilter(sysAssetInfo)));
        return statistics;
    }

    private List<AssetStatisticsVO.StatItem> convertToStatItems(List<Map<String, Object>> stats) {
        return stats.stream()
            .map(map -> {
                String name = (String) map.get("name");
                Number value = (Number) map.get("value");
                return new AssetStatisticsVO.StatItem(name, value.longValue());
            })
            .collect(Collectors.toList());
    }

    /**
     * 导入资产信息数据
     * 
     * @param assetList 资产信息数据列表
     * @param updateSupport 是否支持更新，如果已存在，则进行更新数据
     * @return 结果
     */
    @Override
    @Transactional
    public String importAsset(List<SysAssetInfo> assetList, boolean updateSupport) {
        if (StringUtils.isNull(assetList) || assetList.size() == 0) {
            throw new ServiceException("导入数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();

        for (SysAssetInfo asset : assetList) {
            try {
                asset.setOrgId(Integer.parseInt(SecurityUtils.getDeptId()+""));
                // 验证必填字段
                String validationError = validateRequiredFields(asset);
                String orgIdName = asset.getOrgIdName();
//                DictUtils.getDictCache()

                if (StringUtils.isNotEmpty(validationError)) {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、资产 " + (StringUtils.isNotEmpty(asset.getSystemName()) ? asset.getSystemName() : "未知") + " 导入失败：" + validationError);
                    continue;
                }
                
                // 验证关联信息必填字段
                boolean hasGxValidationError = false;
                if (asset.getSysAssetGx() != null && !asset.getSysAssetGx().isEmpty()) {
                    for (int i = 0; i < asset.getSysAssetGx().size(); i++) {
                        SysAssetGx gx = asset.getSysAssetGx().get(i);
                        String gxValidationError = validateGxRequiredFields(gx, i + 1);
                        if (StringUtils.isNotEmpty(gxValidationError)) {
                            failureNum++;
                            failureMsg.append("<br/>" + failureNum + "、资产 " + (StringUtils.isNotEmpty(asset.getSystemName()) ? asset.getSystemName() : "未知") + " 第" + (i + 1) + "条关联信息导入失败：" + gxValidationError);
                            hasGxValidationError = true;
                            break;
                        }
                    }
                }
                
                if (hasGxValidationError) {
                    continue;
                }
                
                // 验证是否存在这个资产
                SysAssetInfo existAsset = sysAssetInfoMapper.selectSysAssetInfoByAssetId(Long.parseLong(asset.getAssetId()));
                if (StringUtils.isNull(existAsset)) {
                    // 不存在，执行插入
                    asset.setCreateTime(DateUtils.getNowDate());
                    this.insertSysAssetInfo(asset);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、资产 " + asset.getSystemName() + " 导入成功");
                } else if (updateSupport) {
                    // 存在，执行更新
                    asset.setUpdateTime(DateUtils.getNowDate());
                    this.updateSysAssetInfo(asset);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、资产 " + asset.getSystemName() + " 更新成功");
                } else {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、资产 " + asset.getSystemName() + " 已存在");
                }
            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + failureNum + "、资产 " + (StringUtils.isNotEmpty(asset.getSystemName()) ? asset.getSystemName() : "未知") + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
            }
        }

        if (failureNum > 0) {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }

    /**
     * 验证必填字段
     * 
     * @param asset 资产信息
     * @return 验证错误信息，如果为空则表示验证通过
     */
    private String validateRequiredFields(SysAssetInfo asset) {
        StringBuilder errorMsg = new StringBuilder();
        

        // 验证单位类型
        if (StringUtils.isEmpty(asset.getOrgType())) {
            errorMsg.append("单位类型不能为空；");
        }
        
        // 验证系统名称
        if (StringUtils.isEmpty(asset.getSystemName())) {
            errorMsg.append("系统名称不能为空；");
        }
        
        // 验证系统类型
        if (StringUtils.isEmpty(asset.getSystemType())) {
            errorMsg.append("系统类型不能为空；");
        }
        
        // 验证系统用户数量
        if (asset.getUserCount() == null) {
            errorMsg.append("系统用户数量不能为空；");
        }
        
        // 验证系统业务主管单位
        if (StringUtils.isEmpty(asset.getBusinessManager())) {
            errorMsg.append("系统业务主管单位不能为空；");
        }
        
        // 验证系统功能简介
        if (StringUtils.isEmpty(asset.getGnjj())) {
            errorMsg.append("系统功能简介不能为空；");
        }
        if(StringUtils.isEmpty(asset.getIsClassified())){
            errorMsg.append("是否定级不能为空；");
        }

        if(!StringUtils.isEmpty(asset.getIsClassified())&&asset.getIsClassified().equals("1")){
            // 验证系统级别
            if (StringUtils.isEmpty(asset.getSystemLevel())) {
                errorMsg.append("系统级别不能为空；");
            }

            // 验证业务信息安全等级
            if (StringUtils.isEmpty(asset.getBusinessSecurityLevel())) {
                errorMsg.append("业务信息安全等级不能为空；");
            }

            // 验证系统服务安全等级
            if (StringUtils.isEmpty(asset.getServiceSecurityLevel())) {
                errorMsg.append("系统服务安全等级不能为空；");
            }

            // 验证是否备案
            if (StringUtils.isEmpty(asset.getIsFiled())) {
                errorMsg.append("是否备案不能为空；");
            }

            // 验证备案编号
            if (StringUtils.isEmpty(asset.getFilingNumber())) {
                errorMsg.append("备案编号不能为空；");
            }

        }


        // 验证是否已测评
        if (StringUtils.isEmpty(asset.getIsEvaluated())) {
            errorMsg.append("是否已测评不能为空；");
        }
        if (!StringUtils.isEmpty(asset.getIsEvaluated())&&asset.getIsEvaluated().equals("1")) {
            // 验证最近测评时间
            if (asset.getLastEvaluateTime() == null) {
                errorMsg.append("最近测评时间不能为空；");
            }

            // 验证等级测评结论
            if (StringUtils.isEmpty(asset.getCpjl())) {
                errorMsg.append("等级测评结论不能为空；");
            }

        }


        // 验证是否已开展商用密码应用安全性评估
        if (StringUtils.isEmpty(asset.getIsSecurityEvaluated())) {
            errorMsg.append("是否已开展商用密码应用安全性评估不能为空；");
        }

        if (!StringUtils.isEmpty(asset.getIsSecurityEvaluated())&&asset.getIsSecurityEvaluated().equals("1")) {
            // 验证最近密评时间
            if (asset.getLastSecurityEvaluateTime() == null) {
                errorMsg.append("最近密评时间不能为空；");
            }

        }
        if (StringUtils.isEmpty(asset.getInfoperson())){
            errorMsg.append("系统中是否包含个人信息不能为空；");
        }
        if (!StringUtils.isEmpty(asset.getInfoperson())&&asset.getInfoperson().equals("1")){
            // 验证个人信息类型
            if (StringUtils.isEmpty(asset.getInfoType())) {
                errorMsg.append("个人信息类型不能为空；");
            }
            if(null==asset.getPersoninfocount()){
                // 验证个人信息数量

                    errorMsg.append("个人信息数量不能为空；");

            }
        }

        // 验证是否已开展商用密码应用安全性评估
        if (StringUtils.isEmpty(asset.getIsSecurityEvaluated())) {
            errorMsg.append("是否已开展商用密码应用安全性评估不能为空；");
        }
        // 验证部署位置
        if (StringUtils.isEmpty(asset.getDeployLocation())) {
            errorMsg.append("部署位置不能为空；");
        }
        
        // 验证机房地址
        if (StringUtils.isEmpty(asset.getMachineRoomAddress())) {
            errorMsg.append("机房地址不能为空；");
        }
        
        // 验证是否已通过云计算服务安全评估
        if (StringUtils.isEmpty(asset.getIsCloudEvaluated())) {
            errorMsg.append("是否已通过云计算服务安全评估不能为空；");
        }
        
        // 验证应用-cpu个数
        if (StringUtils.isEmpty(asset.getAppcpusize())) {
            errorMsg.append("应用-cpu个数不能为空；");
        }
        
        // 验证应用-内存大小
        if (StringUtils.isEmpty(asset.getAppnsize())) {
            errorMsg.append("应用-内存大小不能为空；");
        }
        
        // 验证应用-磁盘大小
        if (StringUtils.isEmpty(asset.getAppdisksize())) {
            errorMsg.append("应用-磁盘大小不能为空；");
        }
        
        // 验证操作系统
        if (StringUtils.isEmpty(asset.getOsType())) {
            errorMsg.append("操作系统不能为空；");
        }
        
        // 验证操作系统版本
        if (StringUtils.isEmpty(asset.getOsVersion())) {
            errorMsg.append("操作系统版本不能为空；");
        }
        
        // 验证数据库-cpu个数
        if (StringUtils.isEmpty(asset.getDbcpusize())) {
            errorMsg.append("数据库-cpu个数不能为空；");
        }
        
        // 验证数据库-内存大小
        if (StringUtils.isEmpty(asset.getDbnsize())) {
            errorMsg.append("数据库-内存大小不能为空；");
        }
        
        // 验证数据库-磁盘大小
        if (StringUtils.isEmpty(asset.getDbdisksize())) {
            errorMsg.append("数据库-磁盘大小不能为空；");
        }
        
        // 验证数据库版本
        if (StringUtils.isEmpty(asset.getDatabaseVersion())) {
            errorMsg.append("数据库版本不能为空；");
        }
        
        // 验证中间件
        if (StringUtils.isEmpty(asset.getMiddlewareType())) {
            errorMsg.append("中间件不能为空；");
        }
        
        // 验证应用软件产品
        if (StringUtils.isEmpty(asset.getAppProduct())) {
            errorMsg.append("应用软件产品不能为空；");
        }
        
        // 验证联系人
        if (StringUtils.isEmpty(asset.getContactPerson())) {
            errorMsg.append("联系人不能为空；");
        }
        
        // 验证办公电话
        if (StringUtils.isEmpty(asset.getOfficePhone())) {
            errorMsg.append("办公电话不能为空；");
        }
        
        // 验证手机号
        if (StringUtils.isEmpty(asset.getMobilePhone())) {
            errorMsg.append("手机号不能为空；");
        }
        
        // 验证系统开发单位
        if (StringUtils.isEmpty(asset.getDevelopCompany())) {
            errorMsg.append("系统开发单位不能为空；");
        }
        
        // 验证系统运维单位
        if (StringUtils.isEmpty(asset.getMaintainCompany())) {
            errorMsg.append("系统运维单位不能为空；");
        }
        
        // 验证系统年度运维经费
        if (StringUtils.isEmpty(asset.getXtnf())) {
            errorMsg.append("系统年度运维经费不能为空；");
        }
        
        // 验证系统年度网络安全经费
        if (StringUtils.isEmpty(asset.getXtjf())) {
            errorMsg.append("系统年度网络安全经费不能为空；");
        }
        
        return errorMsg.toString();
    }

    /**
     * 验证关联信息必填字段
     * 
     * @param gx 关联信息
     * @param index 关联信息索引
     * @return 验证错误信息，如果为空则表示验证通过
     */
    private String validateGxRequiredFields(SysAssetGx gx, int index) {
        StringBuilder errorMsg = new StringBuilder();
        
        // 验证访问途径
        if (StringUtils.isEmpty(gx.getAccessMethod())) {
            errorMsg.append("访问途径不能为空；");
        }
        
        // 验证访问域名
        if (StringUtils.isEmpty(gx.getAccessDomain())) {
            errorMsg.append("访问域名不能为空；");
        }
        
        // 验证访问IP
        if (StringUtils.isEmpty(gx.getAccessIp())) {
            errorMsg.append("访问IP不能为空；");
        }
        
        // 验证本地端口
        if (gx.getLocalPort() == null) {
            errorMsg.append("本地端口不能为空；");
        }
        
        // 验证公网端口
        if (StringUtils.isEmpty(gx.getPublicMappedPort())) {
            errorMsg.append("公网端口不能为空；");
        }
        
        // 验证服务器IP地址
        if (StringUtils.isEmpty(gx.getServerIp())) {
            errorMsg.append("服务器IP地址不能为空；");
        }
        
        // 验证资产ID
        if (StringUtils.isEmpty(gx.getAssetId())) {
            errorMsg.append("资产ID不能为空；");
        }
        
        return errorMsg.toString();
    }

    @Override
    public List<SysAssetInfo> selectSysAssetInfoByAssetIds(Long[] assetIds) {
        List<SysAssetInfo> sysAssetInfos = sysAssetInfoMapper.selectSysAssetInfoByAssetIds(assetIds);
        // 增加字典转义
        for (SysAssetInfo info : sysAssetInfos) {
            //身份信息 sys_info_type
            info.setInfoTypeName(DictUtils.getDictLabel("sys_info_type", info.getInfoType()));
            //组织架构名称
            info.setOrgIdName(DictUtils.getDictName("dept"+info.getOrgId()));
            //单位类型
            info.setOrgTypeName(DictUtils.getDictLabel("dept_type", info.getOrgType()));
            //系统类型 sys_type
            info.setSystemTypeName(DictUtils.getDictLabel("sys_type", info.getSystemType()));
            //是否定级 sys_is_dj
            info.setIsClassifiedName(DictUtils.getDictLabel("sys_is_dj", info.getIsClassified()));
            //系统级别 sys_level
            info.setSystemLevelName(DictUtils.getDictLabel("sys_level", info.getSystemLevel()));
            //业务安全等级 sys_sc_level
            info.setBusinessSecurityLevelName(DictUtils.getDictLabel("sys_sc_level", info.getBusinessSecurityLevel()));
            //系统服务安全等级 sys_fw_level
            info.setServiceSecurityLevelName(DictUtils.getDictLabel("sys_fw_level", info.getServiceSecurityLevel()));
            //是否备案  sys_is_ba
            info.setIsFiledName(DictUtils.getDictLabel("sys_is_ba", info.getIsFiled()));
            //是否评测  sys_is_pc
            info.setIsEvaluatedName(DictUtils.getDictLabel("sys_is_pc", info.getIsEvaluated()));

            //操作系统 sys_xt
            info.setOsTypeName(DictUtils.getDictLabel("sys_xt", info.getOsType()));
            //中间件 sys_zjj
            info.setMiddlewareTypeName(DictUtils.getDictLabel("sys_zjj", info.getMiddlewareType()));
            //数据库 sys_db
            info.setDatabaseTypeName(DictUtils.getDictLabel("sys_db", info.getDatabaseType()));
            //应用软件产品 sys_app
            info.setAppProductName(DictUtils.getDictLabel("sys_app", info.getAppProduct()));
            //商用密码 sys_is_pwd
            info.setIsSecurityEvaluatedName(DictUtils.getDictLabel("sys_is_pwd", info.getIsSecurityEvaluated()));
            //云计算服务 sys_is_yun
            info.setIsCloudEvaluatedName(DictUtils.getDictLabel("sys_is_yun", info.getIsCloudEvaluated()));
            //状态 sys_status
            info.setStatusName(DictUtils.getDictLabel("sys_status", info.getStatus()));
        }
        return sysAssetInfos;
    }
}
